

<!DOCTYPE html>
<html lang="zh-CN" data-default-color-scheme=auto>



<head>
  <meta charset="UTF-8">
  <link rel="apple-touch-icon" sizes="76x76" href="https://dwj666.cn/%E6%A3%AE%E6%9E%97.png">
  <link rel="icon" href="https://dwj666.cn/%E6%A3%AE%E6%9E%97.png">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=5.0, shrink-to-fit=no">
  <meta http-equiv="x-ua-compatible" content="ie=edge">
  
  <meta name="theme-color" content="#2f4154">
  <meta name="description" content="重点知识点汇总">
  <meta name="author" content="John Doe">
  <meta name="keywords" content="">
  <meta name="description" content="重点知识点汇总">
<meta property="og:type" content="article">
<meta property="og:title" content="软件设计师知识点总结">
<meta property="og:url" content="http://example.com/2023/02/10/%E7%9F%A5%E8%AF%86%E6%B1%87%E6%80%BB%E6%80%BB%E7%BB%93/index.html">
<meta property="og:site_name" content="藏色的个人博客">
<meta property="og:description" content="重点知识点汇总">
<meta property="og:locale" content="zh_CN">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps1.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps2.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps3.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps4.jpg">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps5.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps6.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps7.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps8.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps9.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps10.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps11.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps12.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps13.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps14.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps15.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps16.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps17.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps18.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps19.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps20.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps21.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps22.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps23.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps24.png">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps25.jpg">
<meta property="og:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps26.jpg">
<meta property="article:published_time" content="2023-02-10T03:01:43.973Z">
<meta property="article:modified_time" content="2023-02-10T03:01:45.749Z">
<meta property="article:author" content="John Doe">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:image" content="file:///C:/Users/15409/AppData/Local/Temp/ksohtml2184/wps1.png">
  
  <title>软件设计师知识点总结 - 藏色的个人博客</title>

  <link  rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4/dist/css/bootstrap.min.css" />


  <link  rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@4/github-markdown.min.css" />
  <link  rel="stylesheet" href="/hexo-gujijih/lib/hint/hint.min.css" />

  
    
    
      
      <link  rel="stylesheet" href="https://cdn.jsdelivr.net/npm/highlight.js@10/styles/github-gist.min.css" />
    
  

  
    <link  rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fancyapps/fancybox@3/dist/jquery.fancybox.min.css" />
  


<!-- 主题依赖的图标库，不要自行修改 -->

<link rel="stylesheet" href="//at.alicdn.com/t/font_1749284_ba1fz6golrf.css">



<link rel="stylesheet" href="//at.alicdn.com/t/font_1736178_kmeydafke9r.css">


<link  rel="stylesheet" href="/hexo-gujijih/css/main.css" />

<!-- 自定义样式保持在最底部 -->


  <script id="fluid-configs">
    var Fluid = window.Fluid || {};
    var CONFIG = {"hostname":"example.com","root":"/hexo-gujijih/","version":"1.8.12","typing":{"enable":true,"typeSpeed":70,"cursorChar":"_","loop":false},"anchorjs":{"enable":true,"element":"h1,h2,h3,h4,h5,h6","placement":"right","visible":"hover","icon":""},"progressbar":{"enable":true,"height_px":3,"color":"#29d","options":{"showSpinner":false,"trickleSpeed":100}},"copy_btn":true,"image_zoom":{"enable":true,"img_url_replace":["",""]},"toc":{"enable":true,"headingSelector":"h1,h2,h3,h4,h5,h6","collapseDepth":0},"lazyload":{"enable":true,"loading_img":"/img/loading.gif","onlypost":false,"offset_factor":2},"web_analytics":{"enable":false,"baidu":null,"google":null,"gtag":null,"tencent":{"sid":null,"cid":null},"woyaola":null,"cnzz":null,"leancloud":{"app_id":null,"app_key":null,"server_url":null,"path":"window.location.pathname"}},"search_path":"/hexo-gujijih/local-search.xml"};
  </script>
  <script  src="/hexo-gujijih/js/utils.js" ></script>
  <script  src="/hexo-gujijih/js/color-schema.js" ></script>
<meta name="generator" content="Hexo 5.4.0"></head>


<body>
  <header style="height: 70vh;">
    <nav id="navbar" class="navbar fixed-top  navbar-expand-lg navbar-dark scrolling-navbar">
  <div class="container">
    <a class="navbar-brand" href="/hexo-gujijih/">
      <strong>藏色的个人博客</strong>
    </a>

    <button id="navbar-toggler-btn" class="navbar-toggler" type="button" data-toggle="collapse"
            data-target="#navbarSupportedContent"
            aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
      <div class="animated-icon"><span></span><span></span><span></span></div>
    </button>

    <!-- Collapsible content -->
    <div class="collapse navbar-collapse" id="navbarSupportedContent">
      <ul class="navbar-nav ml-auto text-center">
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/hexo-gujijih/">
                <i class="iconfont icon-home-fill"></i>
                首页
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/hexo-gujijih/archives/">
                <i class="iconfont icon-archive-fill"></i>
                归档
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/hexo-gujijih/categories/">
                <i class="iconfont icon-category-fill"></i>
                分类
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/hexo-gujijih/tags/">
                <i class="iconfont icon-tags-fill"></i>
                标签
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/hexo-gujijih/about/">
                <i class="iconfont icon-user-fill"></i>
                关于
              </a>
            </li>
          
        
        
          <li class="nav-item" id="search-btn">
            <a class="nav-link" target="_self" href="javascript:;" data-toggle="modal" data-target="#modalSearch" aria-label="Search">
              &nbsp;<i class="iconfont icon-search"></i>&nbsp;
            </a>
          </li>
        
        
          <li class="nav-item" id="color-toggle-btn">
            <a class="nav-link" target="_self" href="javascript:;" aria-label="Color Toggle">&nbsp;<i
                class="iconfont icon-dark" id="color-toggle-icon"></i>&nbsp;</a>
          </li>
        
      </ul>
    </div>
  </div>
</nav>

    <div class="banner" id="banner" parallax=true
         style="background: url('https://dwj666.cn/dmfj.jpg') no-repeat center center;
           background-size: cover;">
      <div class="full-bg-img">
        <div class="mask flex-center" style="background-color: rgba(0, 0, 0, 0.3)">
          <div class="page-header text-center fade-in-up">
            <span class="h2" id="subtitle" title="软件设计师知识点总结">
              
            </span>

            
              <div class="mt-3">
  
  
    <span class="post-meta">
      <i class="iconfont icon-date-fill" aria-hidden="true"></i>
      <time datetime="2023-02-10 11:01" pubdate>
        2023年2月10日 上午
      </time>
    </span>
  
</div>

<div class="mt-1">
  
    <span class="post-meta mr-2">
      <i class="iconfont icon-chart"></i>
      30k 字
    </span>
  

  
    <span class="post-meta mr-2">
      <i class="iconfont icon-clock-fill"></i>
      
      
      92 分钟
    </span>
  

  
  
    
      <!-- 不蒜子统计文章PV -->
      <span id="busuanzi_container_page_pv" style="display: none">
        <i class="iconfont icon-eye" aria-hidden="true"></i>
        <span id="busuanzi_value_page_pv"></span> 次
      </span>
    
  
</div>

            
          </div>

          
        </div>
      </div>
    </div>
  </header>

  <main>
    
      

<div class="container-fluid nopadding-x">
  <div class="row nomargin-x">
    <div class="d-none d-lg-block col-lg-2"></div>
    <div class="col-lg-8 nopadding-x-md">
      <div class="container nopadding-x-md" id="board-ctn">
        <div class="py-5" id="board">
          <article class="post-content mx-auto">
            <!-- SEO header -->
            <h1 style="display: none">软件设计师知识点总结</h1>
            
              <p class="note note-info">
                
                  本文最后更新于：2023年2月10日 上午
                
              </p>
            
            <div class="markdown-body">
              <p>重点知识点汇总</p>
<span id="more"></span>
<p><strong>软件设计师知识点总结</strong></p>
<p><strong>一、软件工程</strong></p>
<p><strong>1.1 软件工程基础知识</strong></p>
<p>l <strong>软件生命周期：</strong></p>
<p>  软件的生存期划分为制定计划、需求分析、设计、编程实现、测试、运行维护等几个阶段，称为软件生命周期。</p>
<p><strong>l</strong> <em><strong>*软件开发模型*</strong></em></p>
<p>常见的软件开发模型有瀑布模型、演化模型、螺旋模型、喷泉模型。</p>
<p>瀑布模型（Waterfall Model）：</p>
<p>缺点：瀑布模型缺乏灵活性，无法通过开发活动澄清本来不够明确的活动。因此，当用户需求比较明确时才使用此模型。</p>
<p>演化模型（Evolutionary Model）：也称为快速原型模型。</p>
<p>快速原型方法可以克服瀑布模型的缺点，减少由于软件需求不明确带来的开发风险，具有显著的效果。</p>
<p>螺旋模型（Spiral Model）：将瀑布模型和演化模型相结合，综合了瀑布模型和演化模型的优点，并增加了风险分析。</p>
<p>包含4个方面活动：制定计划：风险分析：实施工程：客户评价：</p>
<p>喷泉模型（Water Fountain Model）：主要用于描述面向对象的开发过程。喷泉一词体现了面向对象开发过程的迭代和无间隙特征。即允许开发活动交叉、迭代</p>
<p>地进行。</p>
<p>迭代：模型中的开发活动常常需要重复多次，在迭代过程中不断完善软件系统。无间隙：指在开发活动（如分析、设计、编码）之间不存在明显的边界。</p>
<p>V模型（V Model）：该模型强调测试过程应如何与分析、设计等过程相关联。</p>
<p>增量模型（Incremental Model）：好处是软件开发可以较好地适应变化，客户可以不断地看到所开发的软件，从而降低开发风险。</p>
<p>构件：是由多种相互作用的模块所形成的提供特定功能的代码片段构成. </p>
<p><strong>l</strong> <em><strong>*软件开发方法*</strong></em></p>
<p>  软件开发方法是一种使用早已定义好的技术集及符号表示习惯来组织软件生产的过程。包括：结构化的方法  、 Jackson方法 、  面向对象开发方法 </p>
<p>结构化方法指导思想是自顶向下、逐层分解，基本原则是功能的分解与抽象。</p>
<p>Jackson方法:是面向数据结构的开发方法，包括JSP（ Jackson Structure programming）和JSD（ Jackson System Development）</p>
<p>面向对象开发方法：</p>
<p>面向对象方法是以对象为最基本的元素，对象也是分析问题和解决问题的核心。开发方法包括面向对象分析、面向对象设计、面向对象实现。</p>
<p> 面向对象开发方法有Booch方法、Coad方法和OMT方法等。为了统一各种面向对象方法的术语、概念和模型，1997年推出了统一建模语言——UML（Unified Modeling Language），它有标准的建模语言，通过统一的语义和符号表示。</p>
<p><strong>l</strong> <em><strong>*软件项目管理*</strong></em></p>
<p> 软件项目管理包括：成本估计、风险分析、进度管理、人员管理。</p>
<p>成本估算方法：有自顶向下估算法、专家估算法……。</p>
<p>成本估算模型：IBM模型、Putnam模型、COCOMO模型。</p>
<p>风险分析包括4种风险评估活动：</p>
<p>风险识别—建立风险概念的尺度。试图系统化确定对项目计划（估算、进度、资源分配）的威胁。（一个方法是建立风险条目检查表。该风险表可以用于识别风险，并使得人们集中来识别下列常见的、已知的及可预测的风险）</p>
<p>风险预测—描述风险引起的后果。确定风险发生的可能性或概率以及如果风险发生了所产生的后果。</p>
<p>风险评估—估计风险影响的大小。</p>
<p>风险控制—确定风险估计的正确性。辅助项目组建立处理风险的策略。</p>
<p>进度管理：就是对软件开发进度的合理安排，它是如期完成软件项目的重要保证，也是合理分配资源的重要保证。</p>
<p>进度安排的常用描述方法有：甘特图（Gantt图） 计划评审技术图（PERT 图）关键路径法（CPM 图）</p>
<p> CPM和PERT的区别是： CPM是以经验数据为基础来确定各项工作的时间，而PERT则把各项工作的时间作为随机变量来处理。所以，前者往往被称为肯定型网络计划技术，而后者往往被称为非肯定型网络计划技术。前者是以缩短时间、提高投资效益为目的，而后者则能指出缩短时间、节约费用的关键所在。</p>
<p>软件过程管理</p>
<p>软件过程—人们用于开发和维护软件及其相关产品（项目计划、设计文档、代码、测试用例、用户手册等）的一系列活动、包括软件工程活动和软件管理活动，其中必然涉及相关的方法和技术。</p>
<p><em><strong>*※*</strong></em> 软件能力成熟度模型(CMM)  </p>
<p><em><strong>*※*</strong></em> 统一软件开发过程（RUP）</p>
<p><em><strong>*※*</strong></em> 极限编程（XP）</p>
<p><em><strong>*软件能力成熟度模型(Capability  Maturity Model，简称CMM)*</strong></em></p>
<p>软件过程能力—-描述（开发组织和项目组）通过遵循其软件过程能够实现预期结果的程度。</p>
<p>软件能力成熟度—-—个特定软件过程被明确和有效地定义、管理、测量及控制的程度。成熟度可指明一个软件开发组织软件过程的能力的增长潜力。</p>
<p>CMM模型将软件过程能力成熟度划分为5个级别：</p>
<p>(1)初始级 (2)可重复级 (3)已定义级 (4)已管理级 (5)优化级</p>
<p>RUP（Rational Unified Process，统一软件开发过程，统一软件过程)：是一个面向对象且基于网络的程序开发方法论。 RUP好像一个在线的指导者，它可以为所有方面和层次的程序开发提供指导方针，模版以及事例支持。</p>
<p>软件工程过程定义谁在做什么、怎么做以及什么时候做，RUP用四个主要的建模元素表达：</p>
<p> ·角色（Workers）——“谁”</p>
<p> ·活动（Activities）——“怎么做”</p>
<p> ·产品(工件)（Artifacts）——“做什么”</p>
<p> ·工作流（Workflows）——“什么时候做”</p>
<p>角色：它定义的是所执行的一组活动和所拥有的一组文档与模型。是抽象的职责定义，描述某个人或者一个小组的行为与职责。角色并不代表个人，而是说明个人在业务中应该如何表现以及他们应该承担的责任。</p>
<p> RUP预先定义了很多角色：</p>
<p>分析员角色集: 分析员角色集用于组织主要从事需求获取和研究的各种角色 </p>
<p>开发角色集: 开发人员角色集用于组织主要从事软件设计与开发的各种角色。测试员角色集: 测试员角色集用于组织主要从事软件测试的各种角色。 </p>
<p>经理角色集: 经理角色集用于组织主要从事软件工程流程的管理与配置的各种角色。</p>
<p>活动：是一个有明确目的的独立工作单元。即承担这一角色的人必须完成的一组工作。 </p>
<p>产品（工件）：产品是一个过程所生产、修改或使用的一段信息。产品是项目切实的成果，是项目为生产出最终的产品而制造或使用的东西。产品可以</p>
<p>具有不同的形式，如</p>
<p>·模型，如用例模型或设计模型。</p>
<p>·模型元素，如类，用例或子系统。</p>
<p>·文档，如商业用例或软件体系结构文档。</p>
<p>·源代码。</p>
<p>·可执行程序</p>
<p>工作流：仅仅把所有的角色、活动和产品都列举出来还不能够组成过程，另外还需要一种有效的方式，把产生有价值结果的活动序列描述出来，并显示角色之间的交互。工作流是一个产生具有可观察的结果活动序列。UML中，可以用一个序列图、协作图或活动图来表示工作流。</p>
<p>RUP被划分为六个核心“工程”工作流：商业建模工作流、需求工作流、分析和设计工作流、实现工作流、测试工作流、展开工作流</p>
<p>RUP把一个开发周期划分为四个连续的阶段：</p>
<p> 初始阶段（Inception phase）：为系统建立商业用例，确定项目的边界。—生命周期目标里程碑。</p>
<p>精化阶段（Elaboration phase）：分析问题领域，建立一个健全的体系结构基础，编制项目规划，淘汰项目中风险最高的元素。——生命周期体系结构里程碑。</p>
<p>构造阶段（Construction phase）：将开发所有剩余的构件和应用部件，对它们进行测试，并集成到产品中。——初始运行能力里程碑。</p>
<p>移交阶段（Transition phase）：把软件产品交付给用户群。—产品发布里程碑。</p>
<p>l 软件质量管理</p>
<p>软件质量  是指反映软件系统或软件产品满足规定或隐含需求的能力的特征和特性全体。</p>
<p>软件质量保证  是指为软件系统或软件产品充分满足用户要求的质量而进行的有计划、有组织的活动，其目的是产生质量的软件。</p>
<p>软件质量模型：ISO/IEC 9126软件质量模型  Mc Call软件质量模型</p>
<p><em><strong>*1.2 系统分析基础知识*</strong></em></p>
<p>系统分析侧重于从业务全过程的角度进行分析，主要任务。主要内容有：</p>
<p>Ø 业务和数据的流程是否通畅，是否合理</p>
<p>Ø 数据、业务过程和组织管理之间的关系</p>
<p>Ø 原系统管理模式改革和新系统管理方法的实现是</p>
<p>Ø 否具有可行性等。</p>
<p>系统分析的步骤</p>
<p>Ø 对当前系统进行详细调查，收集数据；</p>
<p>Ø 建立当前系统的逻辑模型；</p>
<p>Ø 对现状进行分析，提出改进意见和新系统应达到的目标；</p>
<p>Ø 建立新系统的模型；</p>
<p>Ø 编写系统方案说明书</p>
<p>l 结构化分析方法</p>
<p>  数据流图(Data Flow Diagram,DFD):数据流图就是组织中信息运动的抽象，是信息系统逻辑模型的主要形式。它是一种便于用户理解、分析系统数据流程的图形工具。</p>
<p>数据流图的基本组成及符号</p>
<p>§ 外部项(外部实体)：外部项在数据流图中表示所描述系统的数据来源和去处的各种实体或工作环节。系统开发不能改变这些外部项本身的结构和固有属性。</p>
<p>§ 加工(数据加工)：又称数据处理逻辑，描述系统对信息进行处理的逻辑功能。</p>
<p>§ 数据存储：逻辑意义上的数据存储环节，即系统信息处理功能需要的、不考虑存储物理介质和技术手段的数据存储环节。</p>
<p>§ 数据流：与所描述系统信息处理功能有关的各类信息的载体，是各加工环节进行处理和输出的数据集合。</p>
<p><em><strong>*给出了常用的三类数据流图基本成分的符号*</strong></em></p>
<p><strong>§</strong> <img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps1.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>绘制数据流图的几点注记：</p>
<p>\1. 关于自顶向下、逐层分解</p>
<p>\2. 数据流必须通过加工，即送去加工或从加工环节发出。</p>
<p>\3. 数据存储环节一般作为两个加工环节的界面。</p>
<p>\4. 命名</p>
<p>Ø 名称要反映被命名的成分的真实和全部的意义；</p>
<p>Ø 名称要意义明确，易理解，无歧义；</p>
<p>Ø 进出数据存储环节的数据流如内容和存贮者的数据相同，可采用同一名称。</p>
<p>\5. 编号</p>
<p>  每个数据加工环节和每张数据流图都要编号。按逐层分解的原则，父图与子图的编号要有一致性，一般子图的图号是父图上对应的加工的编号。类似地，在分层数据流图中，如下层图上的数据流或数据存储是由上层图某个成分的分解</p>
<p>而得，则父项与子项的编号要体现数据流图分解的完整性与一致性的原则，如父项编号为 F1或D1，则其子项分别为F1.1，F1.2，…，或D1.1，D1.2，…等。</p>
<p><em><strong>*1.3 系统设计基础知识*</strong></em></p>
<p>耦合:系统内不同模块之间互连程度的度量。块间耦合强弱取决于模块间联系形式及接口的复杂程度。模块间接口的复杂性越高，说明耦合的程度也越高。</p>
<p>数据耦合:如果两个模块彼此间通过数据交换信息，而且每一个参数仅仅为数据，那么这种块间耦合称之为数据耦合。 </p>
<p>控制耦合:如果两个模块彼此间传递的信息中有控制信息，那么这种块间耦合称为控制耦合。 </p>
<p>公共耦合:如果两个模块彼此之间通过一个公共的数据区域传递信息时，则称之为公共耦合或公共数据域耦合。 </p>
<p>内容耦合:如果一个模块需要涉及另一个模块的内部信息时，则这种联系称为内容耦合。 </p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps2.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"> </p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps3.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img">    </p>
<p>内聚:模块内部元素的联系方式，块内联系标志一个模块内部各个元素间彼此结合的紧密程度，主要表现在模块内部各个元素为了执行某一功能而结合在</p>
<p>一起的程度。</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps4.jpg" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>偶然内聚：如果一个模块所要完成的动作之间没有任何关系，或者即使有某种关系，也是非常松散的，就称之为偶然组合。</p>
<p>逻辑内聚：如果一个模块内部的各个组成部分在逻辑上具有相似的处理动作，但功能上、用途上却彼此无关，则称之为逻辑组合。</p>
<p>时间内聚：如果一个模块内部的各个组成部分所包含的处理动作必须在同一时间内执行，则称之为时间组合。</p>
<p>过程内聚：如果一个模块内部的各个组成部分所要完成的动作彼此间没什么关系，但必须以特定的次序(控制流)执行，则称之为过程组合。</p>
<p>通信内聚：如果一个模块内部的各个组成部分所完成的动作都使用了同一个输入数据或产生同一个输出数据，则称之为通信组合。 </p>
<p>顺序内聚：对于一个模块内部的各个组成部分，如果前一部分处理动作的输出是后一部分处理动作的输入，则称之为顺序组合。</p>
<p>功能内聚：如果一个模块内部的各个组成部分全部为执行同一功能而合成为一个整体，则称之为功能组合方式的模块。</p>
<p><em><strong>*1.4 系统实施基础知识*</strong></em></p>
<p>l 系统测试</p>
<p>系统测试：是为了发现错误而执行程序的过程</p>
<p>系统测试的目的：系统测试是以找错误为目的，我们不是要证明程序无错，而是要精心选取那些易于发生错误的测试数据，以十分挑剔的态度，去寻找程序的错误。</p>
<p>系统测试的基本原则：</p>
<p>l 测试工作应避免由原开发软件的个人或小组来承担</p>
<p>l 设计测试用例不仅要包括合理、有效的输入数据，还要包括无效的或不合理的输入数据。</p>
<p>l 设计测试案例时,不仅要确定输入数据，而且要根据系统功能确定预期输出的结果。</p>
<p>l 不仅要检验程序做了该做的事，还要检查程序是否同时做了不该做的事。</p>
<p>l 严格按照测试计划进行，避免测试的随意性</p>
<p>l 保留测试用例，将会给重新测试和追加测试带来方便。  </p>
<p>测试过程：</p>
<p>\1. 制定测试计划</p>
<p>\2. 编制测试大纲</p>
<p>\3. 根据测试大纲设计和生成测试用例</p>
<p>\4. 实施测试</p>
<p>\5. 生成测试报告</p>
<p>系统测试的方法：</p>
<p>1.静态测试：被测程序不在机器上运行，而是采用人工检测和计算机辅助静态分析的手段对程序进行检测。</p>
<p>2.动态测试：通过运行程序发现错误。有黑盒测试法和白盒测试法。</p>
<p>系统测试的步骤：</p>
<p>单元测试：程序中的一个模块或一个子程序，是程序设计的最小单元，是程序最小的独立编译单位。 </p>
<p>集成测试（组装测试）：在每个模块完成了单元测试以后，需要按照设计时作出的层次模块图把它们连接起来，进行组装测试。 </p>
<p>确认测试：经过组装测试，软件已装配完毕，接下来进行的确认测试和系统测试将是以整个软件做为测试对象，且采用黑盒测试方法。</p>
<p>系统测试：将信息系统的所有组成部分包括软件、硬件、用户以及环境等综合在一起进行测试，以保证系统的各组成部分协调运行。</p>
<p><strong>•</strong> <em><strong>*1.5 系统运行和维护基础知识*</strong></em></p>
<p>系统可维护性概念： 维护人员理解、改正、改动和改进这个软件的难易程度。</p>
<p>系统的可维护性的评价指标：可理解性、可测试性、可修改性。</p>
<p>系统维护的内容和类型：硬件维护、软件维护、数据维护。</p>
<p>软件维护：根据需求变化或硬件环境的变化对应用程序进行部分或全部修改。</p>
<p>软件维护包括：</p>
<p>正确性维护：改正在系统开发阶段已发生而系统测试阶段尚未发现的错误。占整个维护工作量的17%-20%。</p>
<p>适应性维护：使应用软件适应信息技术变化和管理需求变化而进行的修改。占整个维护工作量的18%-25%。</p>
<p>完善性维护：为扩充功能和改善性能而进行的修改，主要是对已有的软件系统增加一些在系统分析和设计阶段中没有规定的功能与性能特征。占整个维护工作量的50%-60%。</p>
<p>预防性维护：为改进应用软件的可靠性和可维护性，为了使用硬件环境的变化，主动增加预防性的新的功能，以使应用系统适应各类变化而不被淘汰。占整个维护工作量的4%左右。</p>
<p><strong>•</strong> <em><strong>*二.数据库技术基础知识*</strong></em></p>
<p><strong>•</strong> <em><strong>*2.1 数据库系统的基本概念*</strong></em></p>
<p>DB、DBMS和DBS的定义</p>
<p>DB (数据库) 是长期存储在计算机内、有组织的、统一管理的相关数据的集合。</p>
<p>DBMS(数据库管理系统)是数据库系统中管理数据的软件系统。位于用户与操作系统之间的一层管理软件。</p>
<p>DBS（数据库管理系统）在计算机系统中引入数据库后的系统。是数据库、硬件、软件、数据库管理员及用户的集合。</p>
<p>数据库管理系统的功能</p>
<p>1、数据库的定义功能</p>
<p>DBMS提供数据定义语言(DDL)定义数据库的三级结构，两级映象，定义数据</p>
<p>2、数据库的操作</p>
<p>DBMS提供数据操作语言(DML)实现对数据库中数据的操作。基本数据操作有：检索(查询)、和更新(插入、删除、修改)。</p>
<p>3、数据库的保护功能</p>
<p>DBMS对数据的保护主要通过四个方面实现，因而DBMS中包括四个子系统。</p>
<p>• 数据库恢复</p>
<p>• 数据库的并发控制</p>
<p>• 数据库的完整性控制</p>
<p>• 数据库的安全性控制</p>
<p>4、 数据库存储管理</p>
<p>  DBMS的存储管理子系统提供了数据库中数据和应用程序的一个界面，DBMS存储管理子系统的职责是把各种DML语句转换成底层的与磁盘中数据打交道的操作系统的文件系统命令，起到数据的存储、检索和更新的作用。</p>
<p>5.数据库的维护功能：</p>
<p>数据装载程序、备份程序、文件重组织程序、性能监控程序</p>
<p>\6. 数据字典（DD）</p>
<p>   数据库系统中存放三级结构定义的数据库称为数据字典。对数据库的操作都要通过访问DD才能实现。DD中还存放数据库运行的统计信息，例如记录个数、访问次数等。</p>
<p>2.2 数据库系统的体系结构—三级结构两级映象</p>
<p>l 三级结构：外模式、概念模式、内模式</p>
<p>l 两级映象：外模式/模式映象、模式/内模式映象</p>
<p>l 三级结构：</p>
<p> 外模式：单个用户使用到的那部分数据的描述。</p>
<p> 概念模式：是用户定义的数据库中全部数据逻辑结构的描述。 </p>
<p> 内模式：是数据库在物理存储方面的描述，接近于物理存储设备，涉及到实际数据存储的结构。</p>
<p>l 两级映象</p>
<p> 模式／内模式映象：存在于概念级和内部级之间，用于定义概念模式和内模式之间的对应性。 </p>
<p> 外模式／模式映象：存在于外部级和概念级之间，用于定义外模式和概念模式之间的对应性。</p>
<p>两级数据独立性</p>
<p>数据独立性  是指应用程序和数据库的数据结构之间相互独立，不受影响。分成物理数据独立性和逻辑数据独立性两个级别。</p>
<p>物理数据独立性：数据的内模式修改，模式／内模式也要进行相应的修改，但概念模式尽可能保持不变。</p>
<p>逻辑数据独立性：数据的概念模式修改，外模式／模式也要进行相应的修改，但外模式尽可能保持不变。</p>
<p><strong>•</strong> <em><strong>*2.3 数据模型*</strong></em></p>
<p><strong>•</strong> </p>
<p>数据模型:表示实体类型及实体间联系的模型.根据模型应用的不同目的可以将模型化分为概念数据模型和结构数据模型</p>
<p>概念模型 — ER模型（实体联系模型）</p>
<p>实体间的联系：实体集内部以及实体集的联系。包括一对一的联系、一对多的联系、多对多的联系。</p>
<p>描述实体间联系的模型称为实体联系模型简称ER模型。</p>
<p>结构数据模型：层次模型、网状模型、关系模型</p>
<p>层次模型：用树型结构表示实体类型及实体间联系的数据模型。</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps5.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps6.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>网状模型：用有向图表示实体类型及实体间联系的数据模型.</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps7.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps8.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>关系模型：用二维表格结构表达实体间的联系的数据模型 </p>
<p>关系模型中的基本术语:</p>
<p>关系：二维的数据表，它描述了实体之间的联系。</p>
<p>元组（实体）：数据表中的每一行表示一个实体。</p>
<p>属性（字段）：数据表中的每一列。</p>
<p>域：属性的取值范围。</p>
<p>关系模式：对关系的描述称为关系模式。</p>
<p>关系名（属性名1，属性名2，……，属性名n）</p>
<p>超键(超码)：在关系模式中，能唯一标识元组的属性集。这个属性集可能含有多余的属性。</p>
<p>候选键(候选码)：能唯一标识元组，且又不含有多余的属性一个属性集，即超键中删除多余属性剩下的属性集。</p>
<p>主键(主码)：从候选键中选择一个作为关系模式中用户使用的候选键称为主键。</p>
<p>主属性：包含在任何候选键中的属性称为主属性。不包含在任何候选键中的属性称为非主属性。</p>
<p>外键（外码）：当关系R中的某个属性（或属性组）虽然不是该关系的码，但却是另一个关系S的码，称该属性（或属性组）为R关系的外键。 </p>
<p>全键（全码）：关系模型中所有属性都是这个关系的关键字</p>
<p>关系模型的完整性约束（数据完整性）用来确保数据库中数据的正确性和可靠性。</p>
<p>数据完整性包括：</p>
<p>实体完整性：主键的取值必须唯一，并且不能为空。 </p>
<p>域完整性：保证数据的取值在有效的范围内。</p>
<p>参照完整性：参照完整性是通过主键和外键来保证相关联的表间数据保持一致，避免因一个表的数据修改，而导致关联生效。</p>
<p><em><strong>*2.4*</strong></em> <em><strong>*数据操作*</strong></em></p>
<p>  关系数据库的数据操作语言（DML）的语句分成查询语句和更新语句两大类。查询语句用于描述用户的各种检索要求；更新语句用于描述用户进行插入、删除、修改等操作。</p>
<p>关系查询语言根据其理论基础的不同分成两大类：</p>
<p>关系代数语言：查询操作是以集合操作为基础的DML语言。</p>
<p>关系演算语言：查询操作是以谓词演算为基础的DML语言。</p>
<p>l 关系代数</p>
<p>u 关系代数的五个基本操作—— 并、差、笛卡尔积、投影、选择</p>
<p>u 关系代数的四个组合操作 —— 交、联接、自然连接、除法    </p>
<p>l 关系演算</p>
<p>u 元组关系演算域</p>
<p>u 关系演算</p>
<p>关系代数的五个基本操作：</p>
<p>（1）并（Union）</p>
<p>   设关系R和S具有相同的关系模式，R和S的并是由属于R或属于S的元组构成的集合，记为R∪S。形式定义如下：</p>
<p>​    R∪S≡{t | t∈R ∨ t∈S}， t是元组变量，R和S的元数相同。</p>
<p>（2）差（Difference）</p>
<p>   设关系R和S具有相同的关系模式，R和S的差是由属于R</p>
<p>但不属于S的元组构成的集合，记为R－S。形式定义如下：</p>
<p>​    R－S≡{ t | t∈R ∧ t∈S}，R和S的元数相同。</p>
<p>（3）笛卡尔积</p>
<p>   设关系R和S的元数分别为r和s。定义R和S的笛卡尔积是一个（r+s）元的元组集合，每个元组的前r个分量（属性值）来自R的一个元组，后s个分量来自R的一个元组，记为R×S。形式定义如下：</p>
<p>​    R×S≡{ t |t=&lt;tr,ts&gt;∧tr∈R∧ts∈S}</p>
<p>若R有m个元组，S有n个元组，则R×S有m×n个元组。</p>
<p>（4）投影（Projection）</p>
<p>   这个操作是对一个关系进行垂直分割，消去某些列，并重新安排列的顺序。</p>
<p>  设关系R是k元关系，R在其分量Ai1，…，Aim（m≤k，i1，…，im为1到k间的整数）上的投影用πi1，…，im（R）表示，它是一个m元元组集合，</p>
<p>  形式定义如下：</p>
<p>  πi1，…，im(R)≡{ t| t＝〈ti1，…，tim〉∧〈t1，…，tk〉∈R }</p>
<p>（5）选择（Selection）</p>
<p>   选择操作是根据某些条件对关系做水平分割，即选取符合条件的元组。条件可用命题公式（即计算机语言中的条件表达式）F表示。F中有两种成分：运算对象和运算符。形式定义如下：</p>
<p>​    σF（R）＝{ t | t∈R ∧ F（t）= true }</p>
<p>σ为选择运算符，σF（R）表示从R中挑选满足公式F为真的元组所构成的关系。</p>
<p>关系代数的四个组合操作</p>
<p>（1）交（intersection）</p>
<p>   关系R和S的交是由属于R又属于S的元组构成的集合，记为R∩S，这里要求R和S定义在相同的关系模式上。形式定义如下：</p>
<p>​     R∩S≡{t︱t∈R ∧ t∈S}，R和S的元数相同。</p>
<p>（2）连接（join）</p>
<p>   连接有两种：θ连接和F连接</p>
<p>  ① θ连接 （θ是算术比较符）</p>
<p>​    θ连接是从关系R和S的笛卡儿积中选取属性间满足某一θ操作的元组,</p>
<p>​    R ⋈ S≡{t︱t=&lt;tr，ts&gt;∧tr∈R∧ts∈S∧triθ tsj }因此,θ连接由笛卡尔积和选择操作组合而成。</p>
<p>​      R ⋈ S≡ σiθ（r+j） （R×S）</p>
<p>② F连接 （F是公式）</p>
<p>​    F连接是从关系R和S的笛卡儿积中选取属性间满足某一公式F的元组, 这里F是形为F1∧F2∧…∧Fn的公式，每个FP是形为iθj的式子，而i和j分别为关系R和S的第i、第j个分量的序号。</p>
<p>（3） 自然连接（natural join）</p>
<p>   两个关系R和S的自然连接操作具体计算过程如下：</p>
<p>① 计算R×S ；</p>
<p>   ② 设R和S的公共属性是A1,…,AK，挑选R×S中满足</p>
<p>​     R.A1=S.A1，…，R.AK=S.AK的那些元组；</p>
<p>​    ③去掉S.A1，…，S.AK这些列。形式定义如下：</p>
<p> R⋈S ≡ πi1,…,im (σR.A1=S.A1∧… ∧R.AK=S.AK (R×S)),</p>
<p>​     其中i1,…,im为R和S的全部属性，但公共属性只出现一次。</p>
<p>​        自然连接就是等值连接去掉重复列。</p>
<p>（4）除法（division）</p>
<p>   设关系R和S的元数分别为r和s（设r&gt;s&gt;0），那么R÷S是一个（r-s）元的元组的集合。（R÷S）是满足下列条件的最大关系：其中每个元组t与S中每个元组u组成的新元组&lt;t，u&gt;必在关系R中。 </p>
<p>​    R÷S≡π1,2,…,r-s(R)-π1,2,,，r-s((π1,2,…,r-s(R)×S)-R)  </p>
<p>l 关系演算</p>
<p>元组关系演算</p>
<p>  在元组关系演算中，元组关系演算表达式简称为元组表达式，其一般形式为：</p>
<p>​     { t|P（t）}</p>
<p>其中，t是元组变量，表示一个元数固定的元组；P是公式，在数理逻辑中也称为谓词，也就是计算机语言中的条件表达式。{ t|P（t）}表示满足公式P的所有元组t的集合。 </p>
<p>在元组表达式中，公式由原子公式组成。</p>
<p>原子公式（Atoms）有下列三种形式：</p>
<p> ① R（s） ：s是R的一个元组。</p>
<p> ② s[i]θu[j] ：元组 s的第i个分量与元组u的第j个分量之间</p>
<p>   满足θ关系。</p>
<p> ③ s[i]θa或aθu[j]：a是常量。 </p>
<p>   在定义关系演算操作时，要用到“自由” 和“约束”变量概念。在一个公式中，如果元组变量未用存在量词∃或全称量词”符号定义，那么称为自由元组变量，否则称为约束元组变量。 </p>
<p>关系代数表达式到元组表达式的转换：</p>
<p>  R∪S 可用{ t | R（t）∨S（t）}表示；</p>
<p>  R-S 可用{ t | R（t）∧┐S（t）} 表示； </p>
<p>  R×S可用{ t |（$u）（$v）（R（u）∧S(v) ∧t[1]=u[1]∧t[2]=u[2]∧t[3]=u[3]∧t[4]=v[1]∧t[5]=v[2] ∧t[6]=v[3]）} 表示。  </p>
<p>关系数据库SQL语言： SQL的数据定义、SQL的数据查询、SQL的数据更新</p>
<p>SQL的数据定义——创建表</p>
<p>涉及相应属性列的完整性约束条件：</p>
<p>Ø 主键约束：PRIMARY  KEY</p>
<p>Ø 检查约束：CHECK</p>
<p>Ø 外键约束：FOREIGN KEY</p>
<p>Ø 唯一性约束： UNIQUE</p>
<p>Ø 是否为空值约束：  NULL / NOT NULL </p>
<p>Ø 默认值： DEFAULT</p>
<p>SQL的数据查询</p>
<p>Ø   数据查询语句基本格式如下：</p>
<p>Ø    SELECT  &lt;查询项的列表&gt; </p>
<p>Ø    FROM   &lt;表名&gt;</p>
<p>Ø    WHERE  &lt;条件表达式&gt;</p>
<p>6个聚合函数：</p>
<p>Ø SUM(列名):求某一列的总和(此列的值必须是数值型)</p>
<p>Ø AVG(列名):求某一列的平均值(此列的值必须是数值型)</p>
<p>Ø MIN(列名):求某一列中的最小值</p>
<p>Ø MAX(列名):求某一列中的最大值</p>
<p>Ø COUNT(列名):传回一列中的非NULL值的个数</p>
<p>Ø COUNT(*):传回符合查询条件的元组的个数 </p>
<p>ORDER BY子句——对查询的结果进行排序</p>
<p>   SELECT语句中可以使用ORDER BY子句对查询的结果进行排序，带ASC参数时为升序，带DESC参数时为降序，不待任何参数时为默认方式——升序。</p>
<p> SELECT  &lt;查询项的列表&gt; </p>
<p>  FROM   &lt;表名&gt;</p>
<p>  WHERE &lt;条件表达式&gt;</p>
<p>  ORDER BY &lt;排序表达式&gt; [ASC | DESC]</p>
<p>GROUP BY 子句、 HAVING 子句   ——按条件分类统计   </p>
<p>在SELECT语句中可以使用GROUP BY子句进行分类统计。</p>
<p> GROUP BY子句可以将表达式的值相同的记录归为同一组，从而进行统计。</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps9.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img">语法格式如下：</p>
<p>HAVING 子句指定组或聚合的搜索条件，只能和SELECT语句一起使用，通常和GROUP BY连用。</p>
<p>语法格式如下：</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps10.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"> </p>
<p>范式：满足特定要求得关系模式。</p>
<p>设有关系模式R(U)，X和Y是属性集U的子集， r是R任一具体关系，如果对r的任意两个元组t1和 t2，都有t1［X］= t2［X］导致t1［Y］= t2［Y］，</p>
<p>那么称X函数决定Y或Y函数依赖X，记为X→Y，X→Y为模式R的一个函数依赖。</p>
<p>第一范式</p>
<p>  如果关系模式R的每个关系r的属性值都是不可分的原子值，那么称R是第一范式（first normal form，简记为1NF）的模式。</p>
<p>  满足1NF的关系称为规范化的关系，否则称为非规范化的关系。关系数据库研究的关系都是规范化的关系。</p>
<p>  1NF是关系模式应具备的最起码的条件。在建立关系数据模型时，必须将非规范化形式规范化，</p>
<p>第二范式</p>
<p>  如果关系模式R是1NF，且每个非主属性完全函数依赖于候选键，那么称R是第二范式（2NF）模式。如果数据库模式中每个关系模式都是2NF，则称数据库模式为2NF的数据库模式。</p>
<p>  对于函数依赖W→A，如果存在X⊂W有X→A成立，那么称W→A是局部依赖（A局部依赖于W）；否则称W→A是完全依赖。</p>
<p>第三范式</p>
<p>如果关系模式R是1NF，且每个非主属性都不传递依赖于R的候选键，那么称R是第三范式（3NF）的模式。如果数据库模式中每个关系模式都是3NF，则称其为3NF的数据库模式。如果X→Y，Y→A，且Y→X和  A∈Y，那么称X→A是传递依赖（A传递依赖于X）。</p>
<p>数据库模式设计原则 :</p>
<p>关系模式R相对于函数依赖集分解成数据库模式ρ={R1，R2，。。。Rk }，一般应具有下面几项特性。</p>
<p>(1) Ρ中每个关系模式 上应有某种分时性质（3NF或BCNF）</p>
<p>(2)无损联接。</p>
<p>(3)保持函数的依赖集。</p>
<p>无损联接</p>
<p>  设R是一个关系模式，F是R上的一个函数依赖集。R分解成数据库模式ρ=｛ R1，…，Rk ｝。如果对R中满足F的每一个关系r，都有r=πR1（r）⋈πR2（r）⋈ … ⋈πRk（r）那么称分解ρ相对于F是“无损联接分解” 简称为</p>
<p>“无损分解”，否则称为“损失分解”。</p>
<p>无损联接测试：</p>
<p>  设ρ=｛ R1，R2 ｝是关系模式R的一个分解，F是R上成立的FD集，那么分解ρ相对于F是无损分解的充分必要条件是：</p>
<p>​     （R1∩R2）→（R1－R2）</p>
<p>或    （R1∩R2）→（R2－R1）。</p>
<p>保持函数的依赖集</p>
<p>  保持关系模式一个分解是等价的另一个重要条件是关系模式的函数依赖集在分解后仍在数据库模式中保持不变。</p>
<p>设ρ=｛ R1，…，Rk ｝是R的一个分解，F是R上的函数依赖，如果有</p>
<p> ∪πRi（F）=F，那么称分解ρ保持函数依赖集F。</p>
<p><em><strong>*三.操作系统知识*</strong></em></p>
<p><strong>3.1 操作系统的基本概念</strong></p>
<p>操作系统的定义</p>
<p>  能有效地组织和管理系统中的各种软、硬件资源，合理地组织计算机系统工作流程，控制程序的执行，并且向用户提供一个良好的工作环境和友好的接口。</p>
<p>硬件资源：包括CPU，存储器，输入/输出资源等物理设备。</p>
<p>软件资源：以文件形式保存在存储器上的程序和数据等信息。</p>
<p>操作系统的2个重要作用:</p>
<p>(1) 通过资源管理提高计算机系统的效率</p>
<p>(2) 改善人机界面，向用户提供友好的工作环境</p>
<p>操作系统的4个特征</p>
<p>(1)并发性：计算机系统存在着许多并发执行的活动</p>
<p>(2)共享性：系统中各个并发活动要共享计算机系统中的各种软，硬件资源。</p>
<p>(3)虚拟性：虚拟是操作系统中的重要特征，所谓虚拟就是把物理上的一台设备变成逻辑上的多台设备。</p>
<p>(4)不确定性(异步性)：指进程的执行顺序和执行时间及执行结果的不确定性。</p>
<p>操作系统的5大管理功能</p>
<p> (1) 进程管理</p>
<p> (2) 存储管理</p>
<p> (3) 设备管理</p>
<p> (4) 文件管理</p>
<p> (5) 作业管理</p>
<p>多道程序设计原理：在计算机内存中同时存放几道相互独立的程序，它们在管理程序的控制下相互穿插地运行，共享CPU和外设等资源。</p>
<p> 程序：具有特定功能的一组指令集合，它指出了处理器执行操作的步骤。</p>
<p> 进程：进程是一个程序在一个数据集合上的一次执行。</p>
<p><strong>3.2 进程管理</strong></p>
<p>程序和进程区别：</p>
<p>(1)程序是动态的，进程是动态的。</p>
<p>(2)进程与程序的对应关系：通过多次执行，一个程序可对应多个进程；通过调用关系，一个进程可包括多个程序。</p>
<p>(3)进程是暂时的，程序的永久的：进程是一个状态变化的过程，程序可长久保存。</p>
<p>(4)进程与程序的组成不同：进程的组成包括程序、数据进程控制块（即进程状态信息）。</p>
<p>进程通常由三部分组成：</p>
<p> (1)程序：描述了进程所要完成的功能，是进程执行时不可修改的部分。</p>
<p> (2)数据集合：程序执行时所需要的数据和工作区，为一个进程专用，可修改。</p>
<p> (3)进程控制块PCB (Process Control Block)：包含了进程的描述信息和控制信息，是进程的动态特性的集中反映。PCB包含以下几类信息：进程描述信息、进程控制信息、资源占用信息、CPU现场保护结构。</p>
<p>进程的基本状态及转换：</p>
<p>  进程在生命期内处于且仅处于三种基本状态之一：</p>
<p> 运行态:当一个进程在处理机上运行时，则称该进程处于运行状态。</p>
<p> 就绪态:一个进程获得了除处理机外的一切所需资源，一旦得到处理机即可运行，则称此进程处于就绪状态。</p>
<p> 阻塞态:当一个进程正在等待某一事件发生（例如请求I／O而等待I／O完成等）而暂时停止运行，这时即使把处理机分配给进程也无法运行，故称该进程处于阻塞状态。注意与就绪状态的不同在于即使处理机处于空闲状态也无法运行。 </p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps11.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>① 就绪→运行：调度程序选择一个新的进程运行.</p>
<p>② 运行→就绪：运行进程用完时间片被中断或在抢占调度方式中, 因为一高优先级进程进入就绪状态</p>
<p>③ 运行→阻塞：进程发生I/O请求或等待某事件时</p>
<p>④ 阻塞→就绪：当I/O完成或所等待的事件发生时</p>
<p>进程调度程序：主要任务是按照一定的调度算法从就绪队列中选取一个进程，把处理机分配给此进程使用。</p>
<p>进程调度方式</p>
<p>(1) 非抢占方式：在非抢占方式下，调度程序一旦把 CPU分配给某一进程后便让它一直运行下去，直到进程完成或发生某事件而不能运行时，才将CPU分给其它进程。</p>
<p> 这种调度方式通常用在批处理系统中。它的主要优点是简单、系统开销小。</p>
<p>(2) 抢占方式：当一个进程正在执行时，系统可以基于某种策略剥夺CPU给其它进程。剥夺的原则有：优先权原则、短进程优先原则和时间片原则。</p>
<p> 这种调度方式多用在分时系统和实时系统中，以便及时响应各进程的请求。</p>
<p>进程调度算法</p>
<p>(1)先来先服务FCFS(先进先出调度算法，FIFO)</p>
<p>【算法思想】:最简单的算法</p>
<p>按照进程进入就绪队列的先后次序，分派CPU；</p>
<p>当前进程占用CPU，直到执行完或阻塞，才出让CPU（非抢占方式）。</p>
<p>在进程唤醒后（如I/O完成），并不立即恢复执行，通常等到当前进程出让CPU。</p>
<p>【特点】：</p>
<p>比较有利于长作业，而不利于短作业。</p>
<p>有利于CPU繁忙的作业，而不利于I/O繁忙的作业。</p>
<p>(2)短进程优先调度算法(SJF,SPF)</p>
<p>【算法思想】：选择就绪队列中估计运行时间最短的进程投入运行。通常后来的短作业不抢先正在执行的作业。</p>
<p>【优点】：</p>
<p>比FCFS改善平均周转时间和平均带权周转时间，缩短作业的等待时间；</p>
<p>提高系统的吞吐量； </p>
<p>【缺点】：</p>
<p>对长作业非常不利，可能长时间得不到执行；</p>
<p>未能依据作业的紧迫程度来划分执行的优先级；</p>
<p>难以准确估计作业（进程）的执行时间，从而影响调度性能。</p>
<p>(3)优先权调度算法(HPF—Highest Priority First)</p>
<p>【算法思想】：优先选择就绪队列中优先级最高的进程投入运行。分为：</p>
<p>非抢占式优先级算法：仅发生在进程放弃CPU。</p>
<p>抢占式优先级算法：可剥夺当前运行进程CPU。</p>
<p>【 优先权的类型】</p>
<p>静态优先级：在进程创建时指定优先级, 在进程运行时优先数不变。</p>
<p>动态优先级：在进程创建时创立一个优先级，但在其生命周期内优先数可以动态变化。如等待时间长优先数可改变。</p>
<p>【确定优先级的依据】</p>
<p> 进程类型、对资源的需求、根据用户要求。</p>
<p>(4)高响应比优先 (HRRN, Highest Response Ratio Next )：</p>
<p>​    HRRN是FCFS和SJF的折衷算法，响应比R用下式动态计算：</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps12.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps13.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"><em><strong>*响应比*</strong></em><em><strong>*R =*</strong></em><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps14.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>​    </p>
<p>【特点】：</p>
<p> 等待时间相同要求服务的时间越短优先权越高, 有利于短作业。</p>
<p> 要求服务时间相同,等待时间越长优先权越高,近似于先来先服务。</p>
<p> 长作业的优先权会随等待时间加长而升高,长作业也会得到执行。</p>
<p>(5)时间片轮转调度算法</p>
<p>【算法思想】：</p>
<p>通过时间片轮转，提高进程并发性和响应时间特性，从而提高资源利用率。</p>
<p>将系统中所有的就绪进程按照FCFS原则，排成一个队列。</p>
<p>每次调度时将CPU分派给队首进程，让其执行一个时间片。时间片的长度从几个ms到几百ms。</p>
<p>在一个时间片结束时，发生时钟中断。</p>
<p>调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过CPU现场切换执行当前的队首进程。</p>
<p>进程可以未使用完一个时间片，就出让CPU（如阻塞）。 </p>
<p> (6)多级反馈队列算法(多队列轮转法)</p>
<p>【算法思想】：</p>
<p>  设置多个就绪队列，分别赋予不同的优先级，队列1的优先级最高，其他逐级降低。每队列分配不同的时间片，规定优先级越低则时间片越长。</p>
<p> 新进程就绪后，先投入队列1的末尾，按FCFS算法调度。若一个时间片未能执行完，则降低投入到队列2的末尾；依此类推，降低到最后的队列，则按“时间片轮转”算法调度直到完成。 </p>
<p>  进程由于等待事件而放弃CPU后, 进入等待队列, 一旦等待的事件发生, 则回到原来的就绪队列。</p>
<p>仅当较高优先级的队列为空，才调度较低优先级的队列中的进程执行。如果进程执行时有新进程进入较高优先级的队列，则抢先执行新进程，并把被抢先的进程投入原队列的末尾。</p>
<p>进程互斥—是指当有若干进程都要使用某一资源时，任何时刻最多只允许一个进程去使用，其他要使用该资源的进程必须等待，直到占用资源者释放了该资源。</p>
<p>  这样的资源称为称为互斥资源——打印机，共享变量等。</p>
<p>临界区— 并发进程中与共享变量有关的程序段。</p>
<p>PV操作——进程的互斥</p>
<p> PV操作由P操作和V操作组成，P操作和V操是两个在信号量S上进行的操作。定义如下：</p>
<p> Procedure P(S)</p>
<p>  begin S:=S-1;</p>
<p>  if S&lt;0 then 则该进程进入等待队列；</p>
<p>  end;{P}</p>
<p> Procedure V(S)</p>
<p>  begin S:=S+1;</p>
<p>  if S≤0 then 唤醒一个等待队列中的进程进入就绪；</p>
<p>  end;{V}</p>
<p>例：共享缓存器资源造成的错误</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps15.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>(1)A的执行速度操作B的执行速度，造成缓存器中的数据还没拿走，A又读入新数据覆盖了原有数据。</p>
<p>(2)B的执行速度操作A的执行速度，B从缓存器取出一个记录并加工后，A还没有读入新数据，造成B在缓存器中重复取同一个记录加工。</p>
<p>进程同步—是指并发进程之间存在一种制约关系，一个进程的执行依赖另一个进程的消息，当一个进程没有得到另一个进程的消息时应等待，直到消息到达才被 唤醒。</p>
<p>PV操作——进程的互斥</p>
<p>1.调用P操作测试消息是否到达。若消息尚未到达则S=0，调用P(S)后，让调用者称为等待信号量S的状态；若消息已经存在则S≠0，调用P(S)后进程不会成为等待状态而可继续执行。</p>
<p>2.调用V操作发送消息。任何进程要向进程发送消息时可调用V操作。若调用V操作之前S=0，表示消息产生且无等待消息进程，这是调用V(S),执行S:=S+1使S≠0，意味着消息已存在。若调用V操作之前S＜0，表示消息未产生前已有进程在等待消息，这是调用V(S)后释放一个等待消息者，即表示该进程等待的消息已经到达可以继续执行。</p>
<p>死锁</p>
<p>死锁的概念：</p>
<p>   指多个进程因竞争资源而造成的一种僵局，若无外力作用，这些进程都将永远不能再向前推进。                   </p>
<p>死锁产生的原因</p>
<p> (1)竞争资源</p>
<p>   当系统中供多个进程所共享的资源,不足以同时满足它们的需要时,引起它们对资源的竞争而产生死锁。</p>
<p> (2) 进程推进顺序不当</p>
<p>   进程在运行过程中,请求和释放资源的顺序不当,导致了进程的死锁。</p>
<p>死锁产生的必要条件</p>
<p> (1)互斥使用资源</p>
<p> (2)占有并等待资源</p>
<p> (3)不可剥夺资源</p>
<p> (4)循环等待资源</p>
<p>处理死锁的基本方法</p>
<p>预防死锁</p>
<p>避免死锁 —— 银行家算法</p>
<p>检测死锁</p>
<p>解除死锁</p>
<p>避免死锁 —— 银行家算法</p>
<p>【基本思想】</p>
<p>   银行家算法是通过动态地检测系统中资源分配情况和进程对资源的需求情况来决定如何分配资源的，在能确保系统处于安全状态时才能把资源分配给申请者，从而避免系统发生死锁。</p>
<p><strong>5.1 UML概述</strong></p>
<p>  UML（Unified Modeling Language）是一种基于面向对象的可视化的通用(General)建模语言。为不同领域的用户提供了统一的交流标准 — UML图。</p>
<p>  UML应用领域很广泛，可用于软件开发建模的各个阶段，商业建模（Business Modeling）, 也可用于其它类型的系统。　<br>UML是一种定义良好，易于表达，功能强大且普遍实用的建模语言，不是一种方法，它独立于过程。利用它建模时，可遵循任何类型的建模过程。 </p>
<p>UML的主要内容</p>
<p>（1）UML融合了Booch、OMT和OOSE方法中的基本概念，而且这些基本概念与其他面向对象技术中的基本概念大多相同；</p>
<p>（2）UML不仅仅是上述方法的简单汇合，而是扩展了现有方法的应用范围；</p>
<p>（3）UML是标准的建模语言,而不是标准的开发过程。</p>
<p>1.什么是模型？</p>
<p>模型是对系统的完整的抽象表示，建模是在不同层次上对系统的描述。</p>
<p>2.为什么要建模？</p>
<p>\1. 鉴于软件系统的复杂性和规模的不断增大，需要建立不同的模型对系统的各个层次进行描述。（软件模型包括:数学模型、描述模型和图形模型）</p>
<p>\2. 便于开发人员与用户的交流。</p>
<p>\3. 模型为以后的系统维护和升级提供了文档</p>
<p><em><strong>*建模过程*</strong></em><em><strong>*:*</strong></em></p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps16.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p><em><strong>*UML*</strong></em><em><strong>*作为一种可视化的建模语言，提供了丰富的基于面向对象概念的模型元素及其图形表示元素。*</strong></em></p>
<p><strong>5.1.2  UML的主要内容</strong></p>
<p>UML的定义包括UML语义和UML表示法两个部分。</p>
<p>(1) UML语义  描述基于UML的精确元模型(meta-model)定义。</p>
<p>(2) UML表示法　定义UML符号的表示法,为开发者或开发工具使用这些图形符号和文本语法为系统建模提供了标准。</p>
<p>UML是一种标准化的图形建模语言，它是面向对象分析与设计的一种标准表示。由: 视图(views), 图(Diagrams),模型元素(Model elements)，通用机制(general mechanism)等几个部分构成。</p>
<p>一个系统应从不同的角度进行描述,从一个角度观察到的系统称为一个视图（view）。</p>
<p>视图由多个图（Diagrams）构成，它不是一个图表（Graph）,而是在某一个抽象层上，对系统的抽象表示。</p>
<p>UML语言定义了五种类型，9种不同的图，把它们有机的结合起来就可以描述系统的所有视图。</p>
<p>用例图(Use case diagram) 从用户角度描述系统功能,并指出各功能的操作者。</p>
<p>静态图(Static diagram),表示系统的静态结构。包括类图、对象图、包图。</p>
<p>行为图(Behavior diagram)，描述系统的动态模型和组成对象间的交互关系。包括状态图、活动图。  </p>
<p>交互图(Interactive diagram), 描述对象间的交互关系。包括顺序图、合作图。  </p>
<p>实现图( Implementation diagram ) 用于描述系统的物理实现。包括构件图、部件图。  </p>
<p>UML的9种图</p>
<table>
<thead>
<tr>
<th></th>
<th><em><strong>*图名称*</strong></em></th>
<th><em><strong>*图定义*</strong></em></th>
<th><em><strong>*图性质*</strong></em></th>
</tr>
</thead>
<tbody><tr>
<td>1</td>
<td><em><strong>*类图*</strong></em></td>
<td><em><strong>*一组类、接口、协作及它们的关系*</strong></em></td>
<td><em><strong>*静态图*</strong></em></td>
</tr>
<tr>
<td>2</td>
<td><em><strong>*对象图*</strong></em></td>
<td><em><strong>*一组对象及它们的关系*</strong></em></td>
<td><em><strong>*静态图*</strong></em></td>
</tr>
<tr>
<td>3</td>
<td><em><strong>*用例图*</strong></em></td>
<td><em><strong>*一组用例、参与者及它们的关系*</strong></em></td>
<td><em><strong>*静态图*</strong></em></td>
</tr>
<tr>
<td>4</td>
<td><em><strong>*顺序图*</strong></em></td>
<td><em><strong>*一个交互，强调消息的时间顺序*</strong></em></td>
<td><em><strong>*动态图*</strong></em></td>
</tr>
<tr>
<td>5</td>
<td><em><strong>*协作图*</strong></em></td>
<td><em><strong>*一个交互，强调消息发送和接受的对象的结构组织*</strong></em></td>
<td><em><strong>*动态图*</strong></em></td>
</tr>
<tr>
<td>6</td>
<td><em><strong>*状态图*</strong></em></td>
<td><em><strong>*一个状态机，强调对象按事件排序的行为*</strong></em></td>
<td><em><strong>*动态图*</strong></em></td>
</tr>
<tr>
<td>7</td>
<td><em><strong>*活动图*</strong></em></td>
<td><em><strong>*一个状态机，强调从活动到活动的流动*</strong></em></td>
<td><em><strong>*动态图*</strong></em></td>
</tr>
<tr>
<td>8</td>
<td><em><strong>*构件图*</strong></em></td>
<td><em><strong>*一组构件及关系*</strong></em></td>
<td><em><strong>*静态图*</strong></em></td>
</tr>
<tr>
<td>9</td>
<td><em><strong>*配置图*</strong></em><em><strong>*(*</strong></em><em><strong>*实施图*</strong></em><em><strong>*)*</strong></em></td>
<td><em><strong>*一组接点及它们的关系*</strong></em></td>
<td><em><strong>*静态图*</strong></em></td>
</tr>
</tbody></table>
<p>包图: 包中的类以及包与包之间的关系(静态图)</p>
<p>UML的5种视图</p>
<table>
<thead>
<tr>
<th></th>
<th><em><strong>*视图名称*</strong></em></th>
<th><em><strong>*视图内容*</strong></em></th>
<th><em><strong>*静态表现*</strong></em></th>
<th><em><strong>*动态表现*</strong></em></th>
<th><em><strong>*观察角度*</strong></em></th>
</tr>
</thead>
<tbody><tr>
<td>1</td>
<td><em><strong>*用户模型视图*</strong></em><em><strong>*（用例视图）*</strong></em></td>
<td><em><strong>*系统行为，动力*</strong></em></td>
<td><em><strong>*用例图*</strong></em></td>
<td><em><strong>*交互图、状态图、活动图*</strong></em></td>
<td><em><strong>*用户、*</strong></em><em><strong>*分析员、*</strong></em><em><strong>*测试员*</strong></em></td>
</tr>
<tr>
<td>2</td>
<td><em><strong>*结构模型视图*</strong></em><em><strong>*（设计视图）*</strong></em></td>
<td><em><strong>*问题及解决方案*</strong></em></td>
<td><em><strong>*类图、对象图*</strong></em></td>
<td><em><strong>*交互图、状态图、活动图*</strong></em></td>
<td><em><strong>*类、*</strong></em><em><strong>*接口、*</strong></em><em><strong>*协作*</strong></em></td>
</tr>
<tr>
<td>3</td>
<td><em><strong>*行为模型视图*</strong></em><em><strong>*（进程视图）*</strong></em></td>
<td><em><strong>*性能、可伸缩性，吞吐量*</strong></em></td>
<td><em><strong>*类图、对象图*</strong></em></td>
<td><em><strong>*交互图、状态图、活动图*</strong></em></td>
<td><em><strong>*线程、*</strong></em><em><strong>*进程*</strong></em></td>
</tr>
<tr>
<td>4</td>
<td><em><strong>*实现模型视图*</strong></em><em><strong>*（实现视图）*</strong></em></td>
<td><em><strong>*构件、文件*</strong></em></td>
<td><em><strong>*构件图*</strong></em></td>
<td><em><strong>*交互图、状态图、活动图*</strong></em></td>
<td><em><strong>*配置、*</strong></em><em><strong>*发布*</strong></em></td>
</tr>
<tr>
<td>5</td>
<td><em><strong>*环境模型视图*</strong></em><em><strong>*（实施视图）*</strong></em></td>
<td><em><strong>*部件的发布、交付、安装*</strong></em></td>
<td><em><strong>*配置图*</strong></em><em><strong>*(*</strong></em><em><strong>*实施图*</strong></em><em><strong>*)*</strong></em></td>
<td><em><strong>*交互图、状态图、活动图*</strong></em></td>
<td><em><strong>*拓扑结构*</strong></em>                                                          <em><strong>*的节点*</strong></em></td>
</tr>
</tbody></table>
<p>模型元素(Model elements)</p>
<p>　　代表面向对象中的类，对象，关系和消息等概念，是构成图的最基本的常用的元素。一个模型元素可以用于多个不同的图中。</p>
<p>通用机制(general mechanism)</p>
<p>  用于表示其他信息，比如注释，模型元素的语义等。另外，为了适应用户的需求，它还提供了扩展机制(Extensibility mechanisms) ，包括构造型(Stereotype)、标记值(Tagged value)和约束(Constraint).使用UML语言能够适应一个特殊的方法（或过程），或扩充至一个组织或用户。</p>
<p>模型元素(Model elements)</p>
<p><strong>5.1.3 UML的特点</strong></p>
<p>(1) 统一标准</p>
<p>　　UML统一了Booch、OMT和OOSE等方法中的基本概念，已成为OMG的正式标准，提供了标准的面向对象的模型元素的定义和表示。</p>
<p>　(2) 面向对象</p>
<p>　　UML还吸取了面向对象技术领域中其它流派的精华。删除了大量易引起混乱的、多余的和极少使用的符号,也添加了一些新符号。</p>
<p> (3) 可视化、表示能力强</p>
<p>　　系统的逻辑模型或实现模型都能用UML模型清晰的表示，可用于复杂软件系统的建模。</p>
<p>　(4)易掌握、易用</p>
<p>​    UML的概念明确，建模表示法简洁明了，图形结构清晰，易于掌握使用。</p>
<p>5.2 通用模型元素</p>
<p>模型元素是UML构造系统的各种元素，是UML构建模型的基本单位。分为以下两类：</p>
<p>\1. 基元素</p>
<p> 是由UML定义的模型元素。如：类、结点、构件、注释、关联、依赖和泛化等。</p>
<p>\2. 构造型元素</p>
<p> 在基元素的基础上增加了新的定义而构造的新的模型元素。如扩展基元素的语义（不能扩展语法结构）,也允许用户自定义。</p>
<p> 构造型元素用括在双尖括号&lt;&lt; &gt;&gt;中的字符串表示。</p>
<p> 目前UML提供了40多个预定义的构造型元素。如包含&lt;<include>&gt;、扩展&lt;&lt; Extend &gt;&gt;。</p>
<p>5.2.1 常用模型元素</p>
<p>可以在图中使用的概念统称为模型元素。模型元素在图中用其相应的视图元素（符号）表示，图中给出了常用的元素符号：类、对象、结点、包和组件等。</p>
<p>模型元素与模型元素之间的连接关系也是模型元素，常见的关系有关联（association）、泛化（generalization）、依赖(dependency)和聚合(aggregation)，其中聚合是关联的一种特殊形式。这些关系的图示符号如图所示。</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps17.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>关联：连接（connect）模型元素及链接(link)实例。</p>
<p> 依赖：表示一个元素以某种方式依赖于另一种元素。</p>
<p> 泛化：表示一般与特殊的关系，即“一般”元素是“特殊”关系的泛化。</p>
<p> 聚合：表示整体与部分的关系。</p>
<p><strong>5.2.2 关联和链</strong></p>
<p><em><strong>*关联（*</strong></em><em><strong>*association*</strong></em><em><strong>*）是两个或多个类之间的一个关系。链（*</strong></em><em><strong>*link*</strong></em><em><strong>*)是关联的具体体现。关联分为*</strong></em><em><strong>*二元关联(*</strong></em><em><strong>*binary*</strong></em><em><strong>*)、三元关联(*</strong></em><em><strong>*ternary*</strong></em><em><strong>*)、多元关联(*</strong></em><em><strong>*higher order*</strong></em><em><strong>*)。*</strong></em>　</p>
<p><strong>5.2.3 关联的表示</strong></p>
<p>关联的重数</p>
<p>重数(multiplicity)表示多少个对象与对方对象相连接，常用的重数符号有：</p>
<p> “0..1”    表示零或1</p>
<p> “0..<em>”或“</em>”  表示零或多个</p>
<p> “1..*”    表示1或多个</p>
<p> “1,3,7”  表示1或3或7（枚举型）</p>
<p>重数的默认值为1。</p>
<p>有序关联与导航（导引）</p>
<p>  在关联的多端标注{ordered}指明这些对象是有序的。</p>
<p>  关联可以用箭头，表示该关联使用的方向(单向或双向)，称为导引或导航(navigation)。</p>
<p>受限关联(qualified association)</p>
<p>  使用限定词对该关联的另一端的对象进行明确的标识和鉴别,如图。如果对关联的含义作出某种限制，称为受限关联。</p>
<p><strong>5.2.4 约束</strong></p>
<p>UML中提供了一种简便、统一和一致的约束（constraint），是各种模型元素的一种语义条件或限制。一条约束只能应用于同一类的元素。</p>
<p>  约束的表示</p>
<p>如果约束应用于一种具有相应视图元素的模型元素，它可以出现在它所约束元素视图元素的旁边。</p>
<p>  通常一个约束由一对花括号括起来（{constraint}），花括号中为约束内容,如果一条约束涉及同一种类的多个元素，则要用虚线把所有受约束的元素框起来，并把该约束显示在旁边（如或约束）。</p>
<p>约束可分为：对泛化的约束、关联的约束</p>
<p>对泛化的约束</p>
<p>应用于泛化的约束，显示在大括号里，若有多个约束，用逗号隔开。如果没有共享，则用一条虚线通过所有继承线，并在虚线的旁边显示约束。 </p>
<p>对泛化有以下常用的约束： </p>
<p> \1. complete: 说明泛化中所有子元素都已在模型中说明，不允许再增加其它子元素。</p>
<p> \2. disjoint: 父类对象不能有多于一个型的子对象。</p>
<p> \3. incomplete: 说明不是泛化中所有子元素都已说明，允许再增加其它子元素。</p>
<p> \4. overlapping: 给定父类对象可有多于一个型的子对象，表示重载。</p>
<p>对关联有以下常用的约束： </p>
<p> 1.implicit:该关联只是概念性的,在对模型进行精化时不再用。</p>
<p> 2.ordered:具有多重性的关联一端的对象是有序的。</p>
<p> 3.changeable:关联对象之间的链(Link)是可变的（添加、修改、删除）。</p>
<p> 4.addonly:可在任意时刻增加新的链接。</p>
<p> 5.frozen:冻结已创建的对象,不能再添加、删除和修改它的链接。</p>
<p> 6.xor: “或约束”，某时刻只有一个当前的关联实例。</p>
<p><strong>5.2.6 依赖</strong></p>
<p>依赖关系  描述的是两个模型元素（类，组合，用例等）之间的语义上的连接关系，其中一个模型元素是独立的，另一个模型元素是非独立的（或依赖的）。 </p>
<p>依赖的形式可能是多样的，针对不同的依赖的形式，依赖关系有不同的变体(varieties)：<br>&lt;1&gt;抽象(abstraction)：从一个对象中提取一些特性，并用类方法表示。<br>&lt;2&gt;绑定(binding)：为模板参数指定值，以定义一个新的模板元素。<br>&lt;3&gt;组合(combination)：对不同类或包进行性质相似融合。<br>&lt;4&gt;许可(permission)：允许另一个对象对本对象的访问。<br>&lt;5&gt;使用(usage)：声明使用一个模型元素需要用到已存在的另一个模型元素，       这样才能正确实现使用者的功能(包括调用、实例化、参数、发送)。<br>&lt;6&gt;跟踪(trace)：声明不同模型中元素的之间的存在一些连接。<br>&lt;7&gt;访问或连接(access)：允许一个包访问另一个包的内容。<br>&lt;8&gt;调用(call)：声明一个类调用其他类的操作的方法。</p>
<p> &lt;9&gt;导出(derive)：声明一个实例可从另一个实例导出。<br>&lt;10&gt;友元(friend)：允许一个元素访问另一个元素，不管被访问的元素是否具 有可见性。<br>&lt;11&gt;引入(import)：允许一个包访问另一个包的内容并被访问组成部分增加别 名。<br>&lt;12&gt;实例(instantiation)：关于一个类的方法创建了另一个类的实例声明。<br>&lt;13&gt;参数(parameter)：一个操作和它参数之间的关系。<br>&lt;14&gt;实现(realize)：说明和其实之间的关系。<br>&lt;15&gt;精化(refine)：声明具有两个不同语义层次上的元素之间的映射。<br>&lt;16&gt;发送(send)：信号发送者和信号接收者之间的关系。</p>
<p><strong>5.2.7 细化</strong></p>
<p>有两个元素A和B，若B元素是A元素的详细描述，则称为B元素细化A元素。</p>
<p>细化与类的抽象层次有密切的关系，在构造模型时要经过逐步细化,逐步求精的过程。</p>
<p><strong>5.2.8 注释</strong></p>
<p>注释用于对UML语言的元素或实体进行说明，解释和描述。通常用自然语言进行注释。</p>
<p><strong>5.3 用例建模</strong></p>
<p>UML的用例模型一直被推荐为识别和捕获需求的首选工具!!</p>
<p>用例驱动的系统分析与设计方法已成为面向对象的系统分析与设计方法的主流。</p>
<p><strong>5.3.1 用例建模概述</strong></p>
<p>用例建模技术，用于描述系统的功能需求。在宏观上给出模型的总体轮廓。通过对典型用例的分析，使开发者能够有效地了解用户的需求。</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps18.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps19.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>网络中间层状态包检测防火墙系统 </p>
<p><strong>5.3.2 用例模型(Use case model)</strong></p>
<p>  用例模型由若干个用例图构成，用例图中主要描述执行者和用例之间的关系。在UML中,构成用例图的主要元素是用例和执行者及其它们之间的联系。</p>
<p>创建用例模型的工作包括：</p>
<p>  定义系统、确定执行者和用例、描述用例、定义用例间的关系、确认模型。</p>
<p>如何建立用例模型</p>
<p>  建立系统用例模型的过程就是对系统进行功能需求分析的过程。</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps20.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps21.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps22.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps23.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"> </p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps24.png" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"> </p>
<p>一、确定执行者(Actor)</p>
<p>　　执行者是指用户在系统中所扮演的角色,执行者用类似人的图形来表示, 但执行者可以是人，也可以是一个外界系统。</p>
<p>如何确定执行者：</p>
<p>1、谁使用系统的主要功能(主执行者)?</p>
<p>2、谁需要从系统获得对日常工作的支持和服务？</p>
<p>3、需要谁维护管理系统的日常运行（副执行者）？</p>
<p>4、系统需要控制哪些硬件设备？</p>
<p>5、系统需要与其它哪些系统交互？</p>
<p>6、谁需要使用系统产生的结果（值)？</p>
<p>二、 用例</p>
<p>如何确定用例：</p>
<p>1、与系统实现有关的主要问题是什么？</p>
<p>2、系统需要哪些输入/输出？这些输入/输出从何而来？到哪里去？</p>
<p>3、执行者需要系统提供哪些功能？</p>
<p>4、执行者是否需要对系统中的信息进行读、创建、修改、删除或存储？</p>
<p>三、用例之间的关系</p>
<p> 执行者与用例之间通常是一种关联。</p>
<p>用例之间的联系：</p>
<p>&lt;<Use>&gt;表示一个用例使用另一个用例。</p>
<p>&lt;<Extend>&gt;通过向被扩展的用例添加动作来扩展用例。</p>
<p>&lt;<include>&gt;表示一个用例的行为包含了另一个用例的行为。</p>
<p>其中:&lt;<Use>&gt;,&lt;<Extend>&gt;是一种泛化关系。</p>
<p>​     &lt;<include>&gt;是一种依赖关系。</p>
<p><strong>专题一：计算机系统知识</strong></p>
<p>1、计算机硬件基础知识：</p>
<p><strong>1.1计算机系统结构</strong></p>
<p>计算机的发展历史：<br>1946年，世界上第一台电子计算机ENIAC出现，之后经历了5个发展阶段：</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps25.jpg" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>计算机的组成部分：存储器、运算器、控制器、输入设备和输出设备。</p>
<p>计算机的工作过程：一般是由用户使用各种编程语言把所需要完成的任务以程序的形式提交给计算机，然后翻译成计算机能直接执行的机器语言程序，在计算机上运行。</p>
<p>计算机系统可以由下面的模型表示：</p>
<p><img src="file:///C:\Users\15409\AppData\Local\Temp\ksohtml2184\wps26.jpg" srcset="/hexo-gujijih/img/loading.gif" lazyload alt="img"></p>
<p>计算机系统结构（computer architecture）：指机器语言级机器（物理机器）的系统结构，它主要研究软件、硬件功能分配，确定软件、硬件界面（机器级界面），</p>
<p>计算机组成（computer organization）：是指计算机系统的逻辑实现.目标是合理的把各种部件、设备组成计算机，以实现特定的系统结构，同时满足所希望达到的性能价格比。</p>
<p>计算机实现（computer implementation）是指计算机组成的物理实现。 </p>
<p>计算机系统的分类：Flynn分类、冯氏分类、Handler分类和Kuck分类；</p>
<p>Flynn分类：根据不同指令流—数据流组织方式把计算机系统分成4类。（重点理解）</p>
<p>指令流：机器指令的执行序列；</p>
<p>数据流：由指令流调用的数据序列，包括输入数据和中间结果；</p>
<p>多倍性：在系统性能的瓶颈部件上同时处于同样执行阶段的指令和数据的最大可能个数；</p>
<p><strong>I.   单指令流单数据流SISD——如单处理机</strong></p>
<p><strong>II.  单指令流多数据流SIMD——如相联处理机</strong></p>
<p><strong>III.  多指令流单数据流MISD——如流水线计算机</strong></p>
<p><strong>IV.  多指令流多数据流MIMD——如多处理机</strong></p>
<p>(7) 数据校验码：基本思想是把数据可能出现的编码区分为合法编码和错误编码。</p>
<p>码距:是指一个编码系统中任意两个合法编码之间至少有多少个二进制位不同。码距为1的编码是不能发现错误的。</p>
<p>常用的校验码有3种。</p>
<p>▲奇偶校验码：不能发现偶数位错误. 该编码通过增加一位校验位来使编码中1的个数为奇数（奇校验）或者为偶数（偶校验）从而使码距变为2，来检测数据代码中奇数出错的编码。因为其利用的是编码中1的个数的奇偶性作为依据，所以不能发现偶数位错误。</p>
<p>校验位的添加方法有三种：</p>
<p>水平奇偶校验码：对每个数据的编码添加校验位 </p>
<p>垂直奇偶校验码：对一组数据的相同位添加一个校验位；</p>
<p>水平垂直奇偶校验码：先对一组数据垂直校验，所得结果再添加一位水平校验位；</p>
<p>▲海明校验码：也是利用奇偶性来检错和纠错，通过在数据之间插入k个校验位，扩大数据编码的码距，从而有能力检测出n位错，并能纠正1位或n位错。</p>
<p>▲循环校验码（CRC）校验码：采用模2运算，可检测所有等于、小于校验位长度的突发错，利用生成多项式为k个数据位产生r个校验位进行编码，其编码长度为n=k+rk,又称为（n，k）码，生成的多项式与被校验的数据无关。</p>
<p><strong>1.3存储器系统：</strong></p>
<p>概述：</p>
<p>计算机中的存储系统是用来保存数据和程序的。对存储器最基本的要求就是存储容量要大、存取速度快、成本价格低。为了满足这一要求，提出了多级存储体系结构。一般可分为高速缓冲存储器、主存、外存3个层次，有时候还包括CPU内部的寄存器以及控制存储器。</p>
<p>衡量存储器的主要因素：存储器访问速度、存储容量和存储器的价格；</p>
<p>存储器的介质：半导体、磁介质和光存储器。</p>
<p> 存储器的组成：存储芯片+控制电路（存储体+地址寄存器+数据缓冲器+时序控制）；</p>
<p>存储体系结构从上层到下层离CPU越来越远、存储量越来越大、每位的价格越来越便宜，而且访问的速度越来越慢</p>
<p> 存储器系统分布在计算机各个不同部件的多种存储设备组成，位于CPU内部的寄存器以及用于CU的 </p>
<p>控制寄存器:内部存储器是可以被处理器直接存取的存储器，又称为主存储器，外部存储器需要通过I/O模块与处理器交换数据，又称为辅助存储器，弥补CPU处理器速度之间的差异还设置了CACHE，容量小但速度极快，位于CPU和主存之间，用于存放CPU正在执行的程序段和所需数据。</p>
<p>通常衡量主存容量大小的单位是字节或者字，而外存的容量则用字节来表示。</p>
<p>信息存取方式常用的有4种，</p>
<p>◆顺序存取</p>
<p>存储器的数据是以记录的形式进行组织，对数据的访问必须按特定的线性顺序进行。磁带存储器的存取方式就是顺序存取。</p>
<p>◆直接存取</p>
<p>共享读写装置，但是每个记录都有一个唯一的地址标识，共享的读写装置可以直接移动到目的数据块所在位置进行访问。因此存取时间也是可变的。磁盘存储器采用的这种方式。</p>
<p>◆随机存取</p>
<p>存储器的每一个可寻址单元都具有唯一地址和读写装置，系统可以在相同的时间内对任意一个存储单元的数据进行访问，而与先前的访问序列无关。主存储器采用的是这种方式。</p>
<p>◆相联存取</p>
<p>也是一种随机存取的形式，但是选择某一单元进行读写是取决于其内容而不是其地址。Cache可能采用该方法进行访问。</p>
<p> 主存储器：</p>
<p>通常位于所谓主机的范畴，常称为内存。如果内存的地址为n位，容量为2的n次。</p>
<p>主存储器的种类很多，主要有：</p>
<p>   随机存储器（RAM）：可以读出和写入，随机访问存取，断电消失</p>
<p>​     只读存储器（ROM）：只能读出原有的内容，不能写入新内容</p>
<p>​    可编程ROM（PROM）</p>
<p>​    可擦除PROM（EPROM）</p>
<p>​    电可擦除PROM（E2PROM）</p>
<p>​    闪速存储器（flash memory）</p>
<p>辅助存储器：</p>
<p>位于主机的逻辑范畴之外，常称为外存储器，简称外存。</p>
<p>外存的最大特点是容量大、可靠性高、价格低，主要有两大类。</p>
<p>◆磁表面存储器：这类外存储器主要包括磁带和磁盘存储器。</p>
<p>◆光存储器：是利用激光束在记录表面存储信息，根据激光束的反射光来读出信息。按照它的记录原理可分为形变型、相变型（晶相结构）和磁光型。有CD、CD-ROM、WORM、EOD等。</p>
<p>光盘存储器的特点：</p>
<p>大容量、标准化、相容性、持久性、实用性</p>
<p>Cache存储器：（对系统和应用程序员都是透明的）（重点）</p>
<p>Cache位于主存储器与CPU通用寄存器组之间，全部由硬件来调度，用于提高CPU的数据I/O效率，对程序员和系统程序员都是透明的。Cache容量小但速度快，它在计算机的存储体系中是访问速度最快的层次。</p>
<p>  使用Cache改善系统性能的依据是程序的局部性原理，即程序的地址访问流有很强的时序相关性，未来的访问模式与最近已发生的访问模式相似。根据这一局部性原理，把主存储器中访问概率最高的</p>
<p>内容存放在Cache中，当CPU需要读取数据时就首先在Cache中查找是否有所需内容，如果有则直接从Cache中读取；若没有再从主存中读取该数据，然后同时送往CPU和Cache。</p>
<p>​    系统的平均存储周期t3与命中率h有很密切的关系，如下的公式：</p>
<p>t3=h×t1+(1-h)×t2</p>
<p>​    其中，t1表示Cache的周期时间，t2表示主存的周期时间。</p>
<p><strong>1.4中央处理器CPU</strong></p>
<p> CPU由寄存器组、算术逻辑单元ALU和控制单元CU这3部分组成。</p>
<p>\1. 寄存器组分为两大类：</p>
<p> 用户可见的寄存器，有通用寄存器、数据寄存器、地址寄存器、标志寄存器等；</p>
<p> 状态寄存器，包括程序计数器PC、指令寄存器IR、存储器地址寄存器MAR、存储器缓冲寄存器MBR、程序状态字PSW。</p>
<p>2.运算器ALU：负责对数据进行算术和逻辑运算。</p>
<p>3.控制器CU：负责控制整个计算机系统的运行， </p>
<p>计算机的指令系统：</p>
<p>机器指令的格式、分类及功能:</p>
<p>CPU所完成的操作是由其执行的指令来决定的，这些指令被称为机器指令。</p>
<p>CPU所能执行的所有机器指令的集合称为该CPU的指令系统。</p>
<p>机器指令一般由操作码、源操作数、目的操作数和下一条指令的地址组成。</p>
<p>操作码 指明要执行的操作；</p>
<p>源操作数 是该操作的输入数据；</p>
<p>目的操作数 是该操作的输出数据；</p>
<p>下一条指令地址 通知CPU到该地址去取下一条将执行的指令。</p>
<p>指令系统可分为数据传送类、算术运算类、逻辑类、数据变换类、输入/输出类、系统控制类、控制权转移类等类型。</p>
<p>指令的寻址方式</p>
<p>常用的寻址方式有立即数寻址、直接寻址、间接寻址、寄存器寻址、基址寻址、变址寻址、相对寻址。</p>
<p>指令的执行过程</p>
<p>1.计算下一条要执行的指令的地址；</p>
<p>2.从该地址读取指令；</p>
<p>3.对指令译码以确定其所要实现的功能；</p>
<p>4.计算操作数的地址；</p>
<p>5.从该地址读取操作数；</p>
<p>6.执行操作；</p>
<p>7.保存结果；</p>
<p>I/O系统的工作方式：</p>
<p>程序控制：CPU完全控制，CPU必须时时查询I/O设备的状态； </p>
<p>程序中断：I/O设备以中断方式通知CPU，定期查询状态</p>
<p>DMA方式：CPU只在数据传输前和完成后才介入</p>
<p><strong>1.6 计算机总线结构</strong></p>
<p> 总线：一种连接多个设备的信息传递通道。</p>
<p>典型的计算机总线结构由内部总和外部总线组成。</p>
<p>内部总线用于连接CPU内部各个模块；</p>
<p>外部总线用于连接CPU、存储器和I/O系统，又称为系统总线。</p>
<p>系统总线：可分为 数据总线、地址总线、控制总线3类。</p>
<p>数据总线：各个模块间传送数据的通道； </p>
<p>地址总线：传递地址信息，来指示数据总线上的数据的来源或去向，CPU根据地址信息从相应的存储单元读出数据或向该存储单元写入数据； </p>
<p>控制总线：控制数据总线和地址总线。</p>
<p>1．流水线技术</p>
<p>流水线技术其实是通过并行硬件来提高系统性能的常用方法。基本思想在冯·诺依曼第一台存储程序计算机中已经提出。</p>
<p>流水线技术的基本原理实际上是一种任务分解的技术。</p>
<p>2．RISC技术</p>
<p>RISC</p>
<p>即精简指令集计算机，它的主要特点是CPU的指令集大大简化，从而减少指令的执行周期数，提高运算速度。</p>
<p>一般来说，CPU的执行速度受三个因素的影响：</p>
<p>程序中的指令数I</p>
<p>每条指令执行所需的周期数CPI</p>
<p>每个周期的时间T</p>
<p>它们之间的关系可表示为：程序执行时间=I<em>CPI</em>T</p>
<p>3．并行处理技术</p>
<p>并行性（parallelism）就是指在同一时刻或同一时间间隔内完成两种或两种以上性质相同或不同的工作，只要时间上相互重叠，就都蕴含了并行性。</p>
<p>并行性有两重含义：</p>
<p>同时性（simultaneity）：两个或两个以上事件在同一时刻发生</p>
<p>并发性（concurrency）：两个或两个以上事件在同一时间间隔内发生</p>
<p><strong>1.8 计算机的安全、可靠性评价 *&lt;软件设计师&gt;</strong></p>
<p>安全与保密</p>
<p>  数据加密即是对明文（未经加密的数据）按照某种的加密算法（数据的变换算法）进行处理，而形成难以理解的密文（经加密后的数据）。这是计算机安全中最重要的技术措施之一。</p>
<p>数据加密和解密是一对可逆的过程，其关键在于密钥的管理和加密/解密算法。通常加密/解密算法的设计需要满足3个条件：</p>
<p>​    可逆性</p>
<p>​    密钥安全</p>
<p>​    数据安全</p>
<p>计算机可靠性</p>
<p>串联系统：</p>
<p>该系统由N个子系统组成，当且仅当所有的子系统都能正常工作时，系统才能正常工作。</p>
<p>并联系统：</p>
<p>该系统由N个子系统组成，只要有一个子系统正常工作，系统就能正常运行。</p>
<p>计算机性能评测是为了一定目的、按照一定步骤、选用一定的度量项目通过建模、计算和实验，对计算机性能进行测试并对测试结果作出评价的技术。</p>
<p><strong>常用算法设计方法</strong></p>
<p>　　算法设计是一件非常困难的工作，经常采用的算法设计技术主要有迭代法、穷举搜索法、递推法、贪婪法、回溯法、分治法、动态规划法等等。另外，为了更简洁的形式设计和藐视算法，在算法设计时又常常采用递归技术，用递归描述算法。</p>
<p>一、迭代法</p>
<p>　　迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。</p>
<p>二、穷举搜索法</p>
<p>　　穷举搜索法是对可能是解的众多候选解按某种顺序进行逐一枚举和检验，并从众找出那些符合要求的候选解作为问题的解。</p>
<p>三、递推法</p>
<p>　　递推法是利用问题本身所具有的一种递推关系求问题解的一种方法。</p>
<p>四、递归</p>
<p>　 采用递归描述的算法通常有这样的特征:为求解规模为N的问题，设法将它分解成规模较小的问题，然后从这些小问题的解方便地构造出大问题的解，并且这些规模较小的问题也能采用同样的分解和综合方法，分解成规模更小的问题，并从这些更小问题的解构造出规模较大问题的解。特别地，当规模N=1时，能直接得解。</p>
<p>五、回溯法</p>
<p>回溯法也称为试探法，该方法首先暂时放弃关于问题规模大小的限制，并将问题的候选解按某种顺序逐一枚举和检验。</p>
<p>六、贪婪法</p>
<p>　　贪婪法是一种不追求最优解，只希望得到较为满意解的方法。贪婪法一般可以快速得到满意的解，因为它省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪婪法常以当前情况为基础作最优选择，而不考虑各种可能的整体情况，所以贪婪法不要回溯。</p>
<p>七、分治法</p>
<p>1、分治法的基本思想</p>
<p>任何一个可以用计算机求解的问题所需的计算时间都与其规模N有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。　　</p>
<p>分治法的设计思想是，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。</p>
<p>2、分治法的适用条件</p>
<p>　　分治法所能解决的问题一般具有以下几个特征:</p>
<p>　　(1)该问题的规模缩小到一定的程度就可以容易地解决;</p>
<p>　　(2)该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质;</p>
<p>　　(3)利用该问题分解出的子问题的解可以合并为该问题的解;</p>
<p>　　(4)该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。</p>
<p>3、分治法的基本步骤</p>
<p>　分治法在每一层递归上都有三个步骤:</p>
<p>　　(1)分解:将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题;</p>
<p>　　(2)解决:若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题;</p>
<p>　　(3)合并:将各个子问题的解合并为原问题的解。</p>
<p>八、动态规划法</p>
<p> 为了节约重复求相同子问题的时间，引入一个数组，不管它们是否对最终解有用，把所有子问题的解存于该数组中，这就是动态规划法所采用的基本方法。</p>
<p><strong>java的23种设计模式</strong></p>
<p><strong>创建型模式</strong>      **<br>**1.工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。<br>2.建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。<br>3.工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。<br>\4. 原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。<br>\5. 单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。<br><strong>结构型模式</strong><br>6.适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。<br>7.桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。<br>8.合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。<br>9.装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。 </p>
<p>10.门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。<br>11.享元模式：以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态和内蕴状态是相互独立的。</p>
<p>12、代理模式：给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。<br><strong>行为模式</strong> **<br>**13、责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。<br>14、命令模式：命令模式把一个请求或者操作封装到一个对象中。把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。<br>15、解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。<br>16、迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。<br>17、调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。<br>18、备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。<br>19、观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。<br>20、状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。<br>21、策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。<br> 22、模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。<br>23、访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。</p>

            </div>
            <hr>
            <div>
              <div class="post-metas mb-3">
                
                  <div class="post-meta mr-3">
                    <i class="iconfont icon-category"></i>
                    
                      <a class="hover-with-bg" href="/hexo-gujijih/categories/%E8%BD%AF%E8%80%83/">软考</a>
                    
                  </div>
                
                
              </div>
              
                <p class="note note-warning">
                  
                    本博客所有文章除特别声明外，均采用 <a target="_blank" href="https://creativecommons.org/licenses/by-sa/4.0/deed.zh" rel="nofollow noopener noopener">CC BY-SA 4.0 协议</a> ，转载请注明出处！
                  
                </p>
              
              
                <div class="post-prevnext">
                  <article class="post-prev col-6">
                    
                    
                      <a href="/hexo-gujijih/2023/02/10/UML%E5%92%8C%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/">
                        <i class="iconfont icon-arrowleft"></i>
                        <span class="hidden-mobile">UML基本知识</span>
                        <span class="visible-mobile">上一篇</span>
                      </a>
                    
                  </article>
                  <article class="post-next col-6">
                    
                    
                      <a href="/hexo-gujijih/2023/02/10/%E3%80%90mysql-%E6%97%A5%E5%BF%97%E3%80%91%E4%BA%8C%E8%BF%9B%E5%88%B6%E6%97%A5%E5%BF%97%E5%88%A0%E9%99%A4/">
                        <span class="hidden-mobile">Mysql清理二进制日志文件</span>
                        <span class="visible-mobile">下一篇</span>
                        <i class="iconfont icon-arrowright"></i>
                      </a>
                    
                  </article>
                </div>
              
            </div>

            
              <!-- Comments -->
              <article class="comments" id="comments" lazyload>
                
                  
                
                
  <div id="twikoo"></div>
  <script type="text/javascript">
    Fluid.utils.loadComments('#comments', function() {
      Fluid.utils.createScript('https://cdn.jsdelivr.net/npm/twikoo@1/dist/twikoo.all.min.js', function() {
        var options = Object.assign(
          {"envId":"blog9528-5gm3bi65f33458fb","region":"ap-shanghai","path":"window.location.pathname"},
          {
            el: '#twikoo',
            path: 'window.location.pathname',
            onCommentLoaded: function() {
              Fluid.plugins.initFancyBox('#twikoo .tk-content img:not(.tk-owo-emotion)');
            }
          }
        )
        twikoo.init(options)
      });
    });
  </script>
  <noscript>Please enable JavaScript to view the comments</noscript>


              </article>
            
          </article>
        </div>
      </div>
    </div>
    
      <div class="d-none d-lg-block col-lg-2 toc-container" id="toc-ctn">
        <div id="toc">
  <p class="toc-header"><i class="iconfont icon-list"></i>&nbsp;目录</p>
  <div class="toc-body" id="toc-body"></div>
</div>

      </div>
    
  </div>
</div>

<!-- Custom -->


    

    
      <a id="scroll-top-button" aria-label="TOP" href="#" role="button">
        <i class="iconfont icon-arrowup" aria-hidden="true"></i>
      </a>
    

    
      <div class="modal fade" id="modalSearch" tabindex="-1" role="dialog" aria-labelledby="ModalLabel"
     aria-hidden="true">
  <div class="modal-dialog modal-dialog-scrollable modal-lg" role="document">
    <div class="modal-content">
      <div class="modal-header text-center">
        <h4 class="modal-title w-100 font-weight-bold">搜索</h4>
        <button type="button" id="local-search-close" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">&times;</span>
        </button>
      </div>
      <div class="modal-body mx-3">
        <div class="md-form mb-5">
          <input type="text" id="local-search-input" class="form-control validate">
          <label data-error="x" data-success="v"
                 for="local-search-input">关键词</label>
        </div>
        <div class="list-group" id="local-search-result"></div>
      </div>
    </div>
  </div>
</div>
    

    
  </main>

  <footer class="text-center mt-5 py-3">
  <div class="footer-content">
     <a href="https://hexo.io" target="_blank" rel="nofollow noopener"><span>Hexo</span></a> <i class="iconfont icon-love"></i> <a href="https://github.com/fluid-dev/hexo-theme-fluid" target="_blank" rel="nofollow noopener"><span>Fluid</span></a> 
  </div>
  
  <div class="statistics">
    
    

    
      
        <!-- 不蒜子统计PV -->
        <span id="busuanzi_container_site_pv" style="display: none">
            总访问量 
            <span id="busuanzi_value_site_pv"></span>
             次
          </span>
      
      
        <!-- 不蒜子统计UV -->
        <span id="busuanzi_container_site_uv" style="display: none">
            总访客数 
            <span id="busuanzi_value_site_uv"></span>
             人
          </span>
      
    
  </div>


  

  
</footer>


  <!-- SCRIPTS -->
  
  <script  src="https://cdn.jsdelivr.net/npm/nprogress@0/nprogress.min.js" ></script>
  <link  rel="stylesheet" href="https://cdn.jsdelivr.net/npm/nprogress@0/nprogress.min.css" />

  <script>
    NProgress.configure({"showSpinner":false,"trickleSpeed":100})
    NProgress.start()
    window.addEventListener('load', function() {
      NProgress.done();
    })
  </script>


<script  src="https://cdn.jsdelivr.net/npm/jquery@3/dist/jquery.min.js" ></script>
<script  src="https://cdn.jsdelivr.net/npm/bootstrap@4/dist/js/bootstrap.min.js" ></script>
<script  src="/hexo-gujijih/js/events.js" ></script>
<script  src="/hexo-gujijih/js/plugins.js" ></script>

<!-- Plugins -->


  <script  src="/hexo-gujijih/js/local-search.js" ></script>



  
    <script  src="/hexo-gujijih/js/img-lazyload.js" ></script>
  



  



  
    <script  src="https://cdn.jsdelivr.net/npm/tocbot@4/dist/tocbot.min.js" ></script>
  
  
    <script  src="https://cdn.jsdelivr.net/npm/@fancyapps/fancybox@3/dist/jquery.fancybox.min.js" ></script>
  
  
    <script  src="https://cdn.jsdelivr.net/npm/anchor-js@4/anchor.min.js" ></script>
  
  
    <script defer src="https://cdn.jsdelivr.net/npm/clipboard@2/dist/clipboard.min.js" ></script>
  



  <script defer src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js" ></script>




  <script  src="https://cdn.jsdelivr.net/npm/typed.js@2/lib/typed.min.js" ></script>
  <script>
    (function (window, document) {
      var typing = Fluid.plugins.typing;
      var title = document.getElementById('subtitle').title;
      
      typing(title)
      
    })(window, document);
  </script>















<!-- 主题的启动项 保持在最底部 -->
<script  src="/hexo-gujijih/js/boot.js" ></script>


</body>
</html>
